09 设计模式——解释器模式

返回设计模式博客目录

介绍

解释器（Interpreter）模式：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。

使用场景

在软件开发中，会遇到有些问题多次重复出现，而且有一定的相似性和规律性。如果将它们归纳成一种简单的语言，那么这些问题实例将是该语言的一些句子，这样就可以用“编译原理”中的解释器模式来实现了。

虽然使用解释器模式的实例不是很多，但对于满足以上特点，且对运行效率要求不是很高的应用实例，如果用解释器模式来实现，其效果是非常好的。比如正则表达式、XML文档解释等领域。

优点

扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。
容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。

缺点

执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。
会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。
可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

模式的结构与实现

文法、句子、语法树

解释器模式常用于对简单语言的编译或分析实例中，为了掌握好它的结构与实现，必须先了解编译原理中的“文法、句子、语法树”等相关概念。

文法

文法是用于描述语言的语法结构的形式规则。没有规矩不成方圆，例如，有些人认为完美爱情的准则是“相互吸引、感情专一、任何一方都没有恋爱经历”，虽然最后一条准则较苛刻，但任何事情都要有规则，语言也一样，不管它是机器语言还是自然语言，都有它自己的文法规则。例如，中文中的“句子”的文法如下。

〈主语〉::=〈代词〉|〈名词〉
〈谓语〉::=〈动词〉
〈宾语〉::=〈代词〉|〈名词〉
〈代词〉你|我|他
〈名词〉7大学生I筱霞I英语
〈动词〉::=是|学习

这里的符号“::=”表示“定义为”的意思，用“〈”和“〉”括住的是非终结符，没有括住的是终结符。

句子

句子是语言的基本单位，是语言集中的一个元素，它由终结符构成，能由“文法”推导出。例如，上述文法可以推出“我是大学生”，所以它是句子。

语法树

语法树是句子结构的一种树型表示，它代表了句子的推导结果，它有利于理解句子语法结构的层次。下图所示是“我是大学生”的语法树。

模式的结构

解释器模式包含以下主要角色。

抽象表达式（Abstract Expression）：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
终结符表达式（Terminal Expression）：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
非终结符表达式（Nonterminal Expression）：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
环境（Context）：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

解释器模式的结构图

模式的实现

解释器模式实现的关键是定义文法规则、设计终结符类与非终结符类、画出结构图，必要时构建语法树，其代码结构如下：

// 抽象表达式类
interface AbstractExpression {
    public Object interpret(String info);    // 解释方法
}
// 终结符表达式类
class TerminalExpression implements AbstractExpression {
    public Object interpret(String info) {
        // 对终结符表达式的处理
    }
}
// 非终结符表达式类
class NonterminalExpression implements AbstractExpression {
    private AbstractExpression exp1;
    private AbstractExpression exp2;
    public Object interpret(String info) {
        // 非对终结符表达式的处理
    }
}
// 环境类
class Context {
    private AbstractExpression exp;
    public Context() {
        // 数据初始化
    }
    public void operation(String info) {
        // 调用相关表达式类的解释方法
    }
}

示例

需求：比如算数表达式 m + n + p。代表数字的m、n、p三个字符看成终结符号，+ 看做非终结符号。

1、抽象的算术运算解释器，为所有解释器共性的提取。

public abstract class ArithmeticExpression {
    /**
     * 抽象的解析方法
     * 具体的解析逻辑由具体的子类实现
     * @return 解析得到具体的值
     */
    public abstract int interpret();
}

2、数字解释器，仅仅为了解释数字

public class NumExpression extends ArithmeticExpression {
    private int num;
    public NumExpression(int num) {
        this.num = num;
    }
    @Override
    public int interpret() {
        return num;
    }
}

3、运算符号抽象解释器，为所有运算符号解释器共性的提取

public abstract class OperatorExpression extends ArithmeticExpression {
    // 声明两个成员变量存储运算符号两边的数字解释器
    protected ArithmeticExpression exp1, exp2;
    public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }
}

4、加法运算抽象解释器

public class AdditionExpression extends OperatorExpression {
    public AdditionExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }
    @Override
    public int interpret() {
        return exp1.interpret() + exp2.interpret();
    }
}

5、处理与解释相关的一些业务

public class Calculator {
    // 声明一个 Stack 栈存储并操作所有相关的解释器
    private Stack<ArithmeticExpression> mExpStack = new Stack<>();
    public Calculator(String expression) {
        // 声明两个 TerminalExpression 类型的临时变量，存储运算符左右两边的数字解释器
        ArithmeticExpression exp1, exp2;
        String[] elements = expression.split(" ");
        // 循环遍历表达式元素数组
        for (int i = 0; i < elements.length; i++) {
            // 判断运算符号
            switch (elements[i].charAt(0)) {
                case '+':   // 如果是加号
                    // 将栈中的解释器弹出作为运算符号右边的解释器
                    exp1 = mExpStack.pop();
                    // 同时将运算符号数组下标下一个元素构造为一个数字解释器
                    exp2 = new NumExpression(Integer.valueOf(elements[++i]));
                    // 通过尚明两个数字解释器构造加法运算解释器
                    mExpStack.push(new AdditionExpression(exp1, exp2));
                    break;    
                default:    // 如果是数字
                    // 直接构造数字解释器并压入栈
                    mExpStack.push(new NumExpression(Integer.valueOf(elements[i])));
                    break;
            }
        }
    }
    public int calculate() {
        return mExpStack.pop().interpret();
    }
}

6、客户类

public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("1 + 2 + 3 + 10");
        System.out.println(calculator.calculate());
    }
}

此时只是定义了加法运算，如果需要增加减法运算，则可以在 Calculator 中增加以下分支。

case '-':   //如果是减号
    exp1 = mExpStack.pop();
    exp2 = new NumExpression(Integer.valueOf(elements[++i]));
    mExpStack.push(new SubtractionExpression(exp1, exp2));
    break;

此时，在 Client 中就可以开始使用了。

public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("1 - 2 - 3 + 10");
        System.out.println(calculator.calculate());
    }
}

ANDROID 源码中的实现

AndroidManifest.xml 配置文件的读取。源代码追踪关键词：PackageParser 类的 parseSplitApk()、parseSplitApplication() 方法。

parseSplitApplication

实战

用解释器模式设计一个“韶粵通”公交车卡的读卡器程序。

说明：假如“韶粵通”公交车读卡器可以判断乘客的身份，如果是“韶关”或者“广州”的“老人” “妇女”“儿童”就可以免费乘车，其他人员乘车一次扣 2 元。

分析：本实例用“解释器模式”设计比较适合，首先设计其文法规则如下。

1
2
3

<expression> ::= <city>的<person>
<city> ::= 韶关|广州
<person> ::= 老人|妇女|儿童

然后，根据文法规则按以下步骤设计公交车卡的读卡器程序的类图。

程序代码如下：

/*文法规则
  <expression> ::= <city>的<person>
  <city> ::= 韶关|广州
  <person> ::= 老人|妇女|儿童
*/
public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Context bus = new Context();
        bus.freeRide("韶关的老人");
        bus.freeRide("韶关的年轻人");
        bus.freeRide("广州的妇女");
        bus.freeRide("广州的儿童");
        bus.freeRide("山东的儿童");
    }
}
// 抽象表达式类
interface Expression {
    public boolean interpret(String info);
}
// 终结符表达式类
class TerminalExpression implements Expression {
    private Set<String> set = new HashSet<String>();
    public TerminalExpression(String[] data) {
        for(int i=0; i<data.length; i++) set.add(data[i]);
    }
    public boolean interpret(String info) {
        if (set.contains(info)) {
            return true;
        }
        return false;
    }
}
// 非终结符表达式类
class AndExpression implements Expression {
    private Expression city;    
    private Expression person;
    public AndExpression(Expression city,Expression person) {
        this.city=city;
        this.person=person;
    }
    public boolean interpret(String info) {
        String s[] = info.split("的");       
        return city.interpret(s[0]) && person.interpret(s[1]);
    }
}
// 环境类
class Context {
    private String[] cities = {"韶关","广州"};
    private String[] persons = {"老人","妇女","儿童"};
    private Expression cityPerson;
    public Context() {
        Expression city = new TerminalExpression(cities);
        Expression person = new TerminalExpression(persons);
        cityPerson = new AndExpression(city,person);
    }
    public void freeRide(String info) {
        boolean ok = cityPerson.interpret(info);
        if (ok) System.out.println("您是"+info+"，您本次乘车免费！");
        else System.out.println(info+"，您不是免费人员，本次乘车扣费2元！");   
    }
}

程序运行结果如下：

您是韶关的老人，您本次乘车免费！
韶关的年轻人，您不是免费人员，本次乘车扣费2元！
您是广州的妇女，您本次乘车免费！
您是广州的儿童，您本次乘车免费！
山东的儿童，您不是免费人员，本次乘车扣费2元！

数学公式解析器

在项目开发中，如果要对数据表达式进行分析与计算，无须再用解释器模式进行设计了，Java 提供了以下强大的数学公式解析器：Expression4J、MESP(Math Expression String Parser) 和 Jep 等，它们可以解释一些复杂的文法，功能强大，使用简单。

public class JepDemo {
    public static void main(String[] args) throws JepException {
        Jep jep = new Jep();
        // 定义要计算的数据表达式
        String 存款利息 = "本金*利率*时间";
        // 给相关变量赋值
        jep.addVariable("本金",10000);
        jep.addVariable("利率",0.038);
        jep.addVariable("时间",2);
        jep.parse(存款利息);    // 解析表达式
        Object accrual=jep.evaluate();    // 计算
        System.out.println("存款利息：" + accrual);
    }
}

程序运行结果如下：

1	存款利息：760.0

参考链接：
设计模式 | 解释器模式及典型应用
 解释器模式（详解版）